package com.hz.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.hz.dao.*;
import com.hz.pojo.Order;
import com.hz.pojo.Proxy;
import com.hz.pojo.SplitRecord;
import com.hz.pojo.User;
import com.hz.service.SplitRecordService;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class SplitRecordServiceImpl implements SplitRecordService {
    @Resource
    private SplitRecordDao splitRecordDao;
    @Resource
    private OrderDao orderDao;
    @Resource
    private UserDao userDao;
    @Resource
    private ProxyDao proxyDao;
    @Resource
    private SafetyInfoDao safetyInfoDao;
    @Resource
    StringRedisTemplate stringRedisTemplate;
    /*@Resource
    private SplitRecord splitRecord;*/
    @Override
    public int addSplitRecord(String order_code) throws Exception {
        /**
         * 一系列的判断和查询 获得一些需要插入的参数 在调用新增分成记录的方法，在调用修改用户账户余额的方法
         */
        //首先要根据订单编号查询订单信息 从中获取用户id，订单总金额
        //从查询到的用户记录中 获取该用户的父级id，即为分成用户id
        //根据这个父级id去查询父级的代理id 如果代理id为1 说明该订单时代理为2的用户产生的，所以该订单的分成方式为直推（2）
        //所以是 2级代理消费，1级代理分成
        //用分成用户id去用户表查询代理id ，再用代理id去代理表查询分成比例
        //分成金额为 总金额*代理分成比例
        //产生一条分成记录 根据分成id去安全信息表修改分成用户的账户余额

        //首先要根据订单编号查询订单信息 从中获取用户id，订单总金额
        //从查询到的用户记录中 获取该用户的父级id，即为分成用户id
        int i = 0;
        int j = 0;
        Order order = orderDao.getOrderById(order_code);;               //定义一个对象
        Long user_id = order.getUser_id();                              //获取该订单对象对应的的用户id（即当前订单所属那个用户）
        Double consume_money = order.getConsume_money();                //获取该订单的消费总金额

        //根据 刚才获取的用户id 查询 该用户的父级id，即为分成用户id
        long user_pid = userDao.getUserById(user_id).getUser_pid();     //user_pid 分成用户id
        //如果user_pid=0 说明这个用户上边没有父级，他就是一级代理
        if(user_pid==0){
            return 0;
        }
        //此时user_pid有值且不为0 所以该用户有父级
        Long proxy_id = userDao.getUserById(user_pid).getProxy_id();    //proxy_id代理id  父级id的代理id

        //产生一条分成记录 根据分成用户id去安全信息表修改分成用户的账户余额
        if(proxy_id==1){
            Proxy proxy = null;
            proxy = proxyDao.getProxy(proxy_id);                        //根据代理id获取代理对象
            proxy.getProxy_split_ratio();                               //根据代理对象获取分成比例

            Double fenchengMoney = consume_money * proxy.getProxy_split_ratio();    //总金额 * 分成比例 = 分成金额

            /* 新增分成记录 */
            i = splitRecordDao.addSplitRecord(order_code,fenchengMoney,user_pid,2L);
            String open_id = userDao.getUserById(user_pid).getOpen_id();            //获取open_id
            /* 修改用户余额 */
            Double account_money = safetyInfoDao.getSafetyInfo(open_id).getAccount_money();     //根据open_id获取余额
            safetyInfoDao.updAccountMoney(open_id,account_money+fenchengMoney);
            User user = JSONObject.parseObject(stringRedisTemplate.opsForValue().get(open_id),User.class);
            user.getSafetyInfo().setAccount_money(account_money+fenchengMoney);
            stringRedisTemplate.opsForValue().set(open_id,JSONObject.toJSONString(user));
        }
        if(proxy_id==2){
            //此时第一个分成用户 user_pid=3
            //                   proxy_id=2
            Proxy proxy1 = null;
            //根据第一个分成用户的代理id去获得代理对象proxy1
            proxy1 = proxyDao.getProxy(proxy_id);
            Double split_ratio1 = proxy1.getProxy_split_ratio();                //根据代理对象proxy1获取分成比例1
            Double fenchengMoney1 = consume_money * split_ratio1;               //总金额 * 分成比例1 = 分成金额
            i = splitRecordDao.addSplitRecord(order_code,fenchengMoney1,user_pid,2L);

            String open_id1 = userDao.getUserById(user_pid).getOpen_id();       //获取open_id1
            Double account_money1 = safetyInfoDao.getSafetyInfo(open_id1).getAccount_money();       //根据open_id获取余额
            safetyInfoDao.updAccountMoney(open_id1,account_money1 + fenchengMoney1);
            //第一个
            User user = JSONObject.parseObject(stringRedisTemplate.opsForValue().get(open_id1),User.class);
            user.getSafetyInfo().setAccount_money(account_money1 + fenchengMoney1);
            stringRedisTemplate.opsForValue().set(open_id1,JSONObject.toJSONString(user));

            Proxy proxy2 = null;
            User p_user = userDao.getUserById(user_pid);
            Long p_user_p_id = p_user.getUser_pid();                            //获取第二个分成用户的id

            //根据第一个分成的用户id获取第二个分成用户对象 在获得他的代理id proxy_id2
            Long proxy_id2 = userDao.getUserById(p_user_p_id).getProxy_id();

            //根据第二个分成用户的代理id去获得代理对象proxy2
            proxy2 = proxyDao.getProxy(proxy_id2);

            Double split_ratio2 = proxy2.getProxy_split_ratio();                //根据代理对象proxy2获取分成比例2

            Double fenchengMoney2 = consume_money * split_ratio2;               //总金额 * 分成比例1 = 分成金额

            j = splitRecordDao.addSplitRecord(
                    order_code,
                    fenchengMoney2,
                    userDao.getUserById(p_user.getUser_pid()).getUser_id(),
                    1L);

            String open_id2 = userDao.getUserById(p_user_p_id).getOpen_id();    //根据第二个分成用户id获取open_id2
            Double account_money2 = safetyInfoDao.getSafetyInfo(open_id2).getAccount_money();       //根据open_id获取余额
            safetyInfoDao.updAccountMoney(open_id2,account_money2 + fenchengMoney2);
            //第二个
            User user2 = JSONObject.parseObject(stringRedisTemplate.opsForValue().get(open_id2),User.class);
            user.getSafetyInfo().setAccount_money(account_money2 + fenchengMoney2);
            stringRedisTemplate.opsForValue().set(open_id2,JSONObject.toJSONString(user2));

        }
        return i;
    }

    @Override
    public List<SplitRecord> getUserFenCheng(Long split_user_id,Integer split_method) throws Exception {
        return splitRecordDao.getUserFenCheng(split_user_id,split_method);
    }

    @Override
    public List<SplitRecord> getUserFenChengCount(Long split_user_id) throws Exception {
        return splitRecordDao.getUserFenChengCount(split_user_id);
    }
}
